/**
 * 数据字典store
 */
import { makeAutoObservable } from "mobx";
import * as _ from "lodash";
import {
  fetchAddDictLabel,
  fetchAllDictLabel,
  fetchDelDictLabel,
  fetchUpdateDictLabel,
  fetchAddDictValue,
  fetchGetDictValueById,
  fetchDelValueById,
  fetchUpdateDictValue,
  fetchFullDict,
} from "../api/dictionary";
import { ITResponseData, checkResonse } from "../api";

import { ITDictValue } from "./interfaces";

interface ITBadResp {
  msg: string;
}

interface ITDictLabel {
  key: string;
  id: string;
  desc: string;
}

interface ITFullDict extends ITDictLabel {
  values: ITDictValue[];
}

export interface ITDictionaryStore {
  // 是否显示新增，编辑弹窗
  showAddEditLabelModal: boolean;

  // 修改是否显示新增，编辑弹窗
  changeShowAddEditLabelModal: (data: boolean) => void;

  // 正在编辑的字典值
  editDictLabelData: any;

  // 修改正在编辑的字典值
  changeEditDictLabelData: (data: any) => void;

  // 新增字典label loading
  showAddLabelLoading: boolean;

  // 修改新增字典label loading
  changeShowAddLabelLoading: (data: boolean) => void;

  // 新增字典
  addDictLabel: (data: any) => Promise<ITBadResp | null>;

  // 所有字典label列表
  allDictLabel: ITDictLabel[];

  // 修改所有字典label列表
  changeAllDictLabel: (data: any) => void;

  // 请求所有字典label状态
  allDictLabelLoading: boolean;

  // 修改请求所有字典label状态
  changeAllDictLabelLoading: (data: boolean) => void;

  // 获取所有字典label列表
  getAllDictLabel: () => Promise<ITBadResp | null>;

  // 删除字典 label loading
  delLabelLoading: boolean;

  // 修改删除字典 label loading
  changeDelLabelLoading: (data: boolean) => void;

  // 删除字典label
  deleteDictLabel: (data: any) => Promise<ITBadResp | null>;

  // 更新字典label
  updateDictLabel: (data: any) => Promise<ITBadResp | null>;

  // 显示label详情
  showDetail: boolean;

  // 修改显示label详情
  changeShowDetail: (data: boolean) => void;

  // 字典label详情数据
  detailLabelData: ITDictLabel | null;

  // 修改字典label详情数据
  changeDetailLabelData: (data: any) => void;

  // 显示字典值弹窗
  showValueModal: boolean;

  // 修改显示字典值弹窗
  changeShowValueModal: (data: boolean) => void;

  // 当前正在修改的标签值
  valueModalData: ITDictValue | null;

  // 修改当前正在修改的标签值
  changeValueModalData: (data: ITDictValue | null) => void;

  // 请求新增字典值状态
  addDictValueLoading: boolean;

  // 修改请求新增字典值状态
  changeAddDictValueLoading: (data: boolean) => void;

  // 新增字典值
  addDictValue: (data: any) => Promise<ITBadResp | null>;

  // 当前标签的值列表
  dictValues: ITDictValue[];

  // 修改当前标签的值列表
  changeDictValues: (data: ITDictValue[]) => void;

  // 更新标签的值
  updateDictValue: (data: any) => Promise<ITBadResp | null>;

  // 请求获取字典值状态
  getDictValueLoading: boolean;

  // 修改请求获取字典值状态
  changeGetDictValueLoading: (data: boolean) => void;

  // 根据id获取所有字典值
  getDictValue: (data: any) => Promise<ITBadResp | null>;

  // 删除字典值状态
  delValueLoading: boolean;

  // 修改删除字典值状态
  changeDelValueLoading: (data: boolean) => void;

  // 删除字典的值
  delValue: (data: any) => Promise<ITBadResp | null>;

  // 完整字典列表
  fullDicts: ITFullDict[];

  // 修改完整字典列表
  changeFullDicts: (data: any) => void;

  // 请求字典和相应的值
  getFullDict: (isModify: boolean) => Promise<ITBadResp | null>;

  // 根据key获取字典的值列表
  getDictValuesByKey: (dictkey: string) => ITDictValue[];
}

class DictionaryStore {
  constructor() {
    makeAutoObservable(this, {}, { autoBind: true });
  }

  showAddEditLabelModal = false;
  changeShowAddEditLabelModal = (data: boolean) =>
    (this.showAddEditLabelModal = data);

  // 正在编辑的字典值
  editDictLabelData: any = null;

  // 修改正在编辑的字典值
  changeEditDictLabelData = (data: any) => (this.editDictLabelData = data);

  showAddLabelLoading = false;
  changeShowAddLabelLoading = (data: boolean) =>
    (this.showAddLabelLoading = data);

  addDictLabel = async (data: any): Promise<ITBadResp | any> => {
    this.changeShowAddLabelLoading(true);
    const res = await fetchAddDictLabel(data);
    this.changeShowAddLabelLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 所有字典label列表
  allDictLabel: ITDictLabel[] = [];

  // 修改所有字典label列表
  changeAllDictLabel = (data: any) => (this.allDictLabel = data);

  // 请求所有字典label状态
  allDictLabelLoading = false;

  // 修改请求所有字典label状态
  changeAllDictLabelLoading = (data: boolean) =>
    (this.allDictLabelLoading = data);

  // 获取所有字典label列表
  getAllDictLabel = async (): Promise<ITBadResp | any> => {
    this.changeAllDictLabelLoading(true);
    const res = await fetchAllDictLabel();
    this.changeAllDictLabelLoading(false);
    if (checkResonse(res)) {
      const result: ITResponseData = res.data;
      const { data } = result;
      this.changeAllDictLabel(data);
    }
  };

  // 删除字典 label loading
  delLabelLoading = false;

  // 修改删除字典 label loading
  changeDelLabelLoading = (data: boolean) => (this.delLabelLoading = data);

  // 删除字典label
  deleteDictLabel = async (data: any): Promise<ITBadResp | any> => {
    this.changeDelLabelLoading(true);
    const res = await fetchDelDictLabel(data);
    this.changeDelLabelLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 更新字典label
  updateDictLabel = async (data: any): Promise<ITBadResp | any> => {
    this.changeShowAddLabelLoading(true);
    const res = await fetchUpdateDictLabel(data);
    this.changeShowAddLabelLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 显示详情
  showDetail = false;

  // 修改显示详情
  changeShowDetail = (data: boolean) => (this.showDetail = data);

  // 字典label详情数据
  detailLabelData = null;

  // 修改字典label详情数据
  changeDetailLabelData = (data: any) => (this.detailLabelData = data);

  // 显示字典值弹窗
  showValueModal = false;

  // 修改显示字典值弹窗
  changeShowValueModal = (data: boolean) => (this.showValueModal = data);

  // 当前正在修改的标签值
  valueModalData: ITDictValue | null = null;

  // 修改当前正在修改的标签值
  changeValueModalData = (data: ITDictValue | null) =>
    (this.valueModalData = data);

  addDictValueLoading = false;

  changeAddDictValueLoading = (data: boolean) =>
    (this.addDictValueLoading = data);

  // 新增字典值
  addDictValue = async (data: any): Promise<ITBadResp | any> => {
    this.changeAddDictValueLoading(true);
    const res = await fetchAddDictValue(data);
    this.changeAddDictValueLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 当前标签的值列表
  dictValues: ITDictValue[] = [];

  // 修改当前标签的值列表
  changeDictValues = (data: ITDictValue[]) => (this.dictValues = data);

  updateDictValue = async (data: any): Promise<ITBadResp | any> => {
    this.changeAddDictValueLoading(true);
    const res = await fetchUpdateDictValue(data);
    this.changeAddDictValueLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 请求获取字典值状态
  getDictValueLoading = false;

  // 修改请求获取字典值状态
  changeGetDictValueLoading = (data: boolean) =>
    (this.getDictValueLoading = data);

  // 根据id获取所有字典值
  getDictValue = async (data: any): Promise<ITBadResp | any> => {
    this.changeGetDictValueLoading(true);
    const res = await fetchGetDictValueById(data);
    this.changeGetDictValueLoading(false);
    if (checkResonse(res)) {
      const result: ITResponseData = res.data;
      const { data } = result;

      let tempData = _.sortBy(data, ["sort"]);

      let list: ITDictValue[] = [];
      tempData.forEach((item: ITDictValue, index: number) => {
        item.key = index;
        list.push(item);
      });
      this.changeDictValues(list);
      return list;
    }
    return null;
  };

  // 删除字典值状态
  delValueLoading = false;

  // 修改删除字典值状态
  changeDelValueLoading = (data: boolean) => (this.delValueLoading = data);

  // 删除字典的值
  delValue = async (data: any): Promise<ITBadResp | any> => {
    this.changeDelValueLoading(true);
    const res = await fetchDelValueById(data);
    this.changeDelValueLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 完整字典列表
  fullDicts: ITFullDict[] = [];

  // 修改完整字典列表
  changeFullDicts = (data: ITFullDict[]) => (this.fullDicts = data);

  // 请求字典和相应的值
  getFullDict = async (isModify: boolean): Promise<ITBadResp | any> => {
    const sesdict: string | null = localStorage.getItem("dict");
    if (!!sesdict && !isModify) {
      try {
        const langJson = JSON.parse(sesdict);
        this.changeFullDicts(langJson);
      } catch (e) {}
    } else {
      const res = await fetchFullDict();
      if (checkResonse(res)) {
        const result: ITResponseData = res.data;
        const { data } = result;
        this.changeFullDicts(data);
        localStorage.setItem("dict", JSON.stringify(data));
      }
    }
  };

  // 根据key获取字典的值列表
  getDictValuesByKey = (dictkey: string): ITDictValue[] => {
    let list: ITDictValue[] = [];
    if (this.fullDicts && this.fullDicts.length) {
      this.fullDicts.some(({ key, values }) => {
        if (key === dictkey) {
          list = _.sortBy(values, "sort");
          return true;
        }
        return false;
      });
    }
    return list;
  };
}

const dictionaryStore: ITDictionaryStore = new DictionaryStore();
export default dictionaryStore;
